﻿//using LinearMotor.ViewModels.Datas;
//using ReactiveUI;
//using ReactiveUI.Fody.Helpers;
//using System;
//using System.Collections;
//using System.Collections.Generic;
//using System.Collections.ObjectModel;
//using System.ComponentModel;
//using System.Diagnostics;
//using System.Diagnostics.Metrics;
//using System.Linq;
//using System.Reactive;
//using System.Text;
//using System.Threading.Tasks;
//using Common.Utils;
//using LinearMotor.ViewModels.Logs;
//using Splat.ApplicationPerformanceMonitoring;
//using DynamicData.Kernel;
//using System.Reflection.Metadata;
//using Common.Entitys.CommonLogs;
//using Common.Utlis;
//using LinearMotor.ViewModels.Messages;
//using LinearMotor.ViewModels.SimulatorModes;
//using DynamicData;
//using LinearMotor.ViewModels.MotorUtils;
//using Newtonsoft.Json;
//using BitConverter = System.BitConverter;
//using Org.BouncyCastle.Crypto.Prng;
//using System.Windows.Interop;
//using LinearMotor.ViewModels.MessageBoxHelp;
//using System.Windows;
//using System.Globalization;
//using System.Windows.Data;
//using ProtoBuf.Meta;
//using LinearMotor.ViewModels.ExtendDevices;
//using LinearMotor.Models;
//using LinearMotor.ViewModels.PeripheralDevices;
//using Car = LinearMotor.ViewModels.SimulatorModes.Car;
//using LinearMotor.ViewModels.SlaveHelps;
//using LibVLCSharp.Shared;
//using System.Diagnostics.SymbolStore;
//using MongoDB.Bson.Serialization.Conventions;
//using System.Runtime.CompilerServices;
//using System.ComponentModel.DataAnnotations;
//using LinearMotor.ViewModels.Axiss.ADT8940A1;
//using MongoDB.Driver.Linq;
//using System.Windows.Documents;
//using MongoDB.Bson.Serialization.Serializers;
//using LinearMotor.ViewModels.Dispatchs;
//using ZstdSharp.Unsafe;
//using ZstdSharp;
//using System.Windows.Markup;
//using MongoDB.Bson.Serialization.Options;
//using Org.BouncyCastle.Asn1.Icao;
//using MongoDB.Driver.Core.Connections;
//using Splat.ModeDetection;
//using MongoDB.Driver.Core.Misc;
//using System.Reactive.Concurrency;
//using System.Runtime.InteropServices;
//using System.Security;
//using S7.Net.Types;
//using DateTime = System.DateTime;
//using String = System.String;
//using System.Windows.Controls;
//using Amazon.Runtime.Internal.Util;
//using Common.Utlis.Extend;
//using Org.BouncyCastle.Utilities.Encoders;

//namespace LinearMotor.ViewModels
//{


//    [Serializable]
//    [JsonObject(MemberSerialization.OptOut)]
//    public partial class FTSSlave : Car
//    {
//        private List<IDisposable> m_Disposables = new List<IDisposable>();

//        /// <summary>
//        /// 偏移量系数(-1/1)
//        /// </summary>
//        [JsonProperty]
//        [Reactive] public double OffsetXCoff { get; set; } = -1;

//        /// <summary>
//        /// Tag
//        /// </summary>
//        [JsonIgnore]
//        [Reactive]
//        public Object Tag { get; set; }

//        /// <summary>
//        /// 请求的消息
//        /// </summary>
//        [JsonIgnore]
//        [Reactive]
//        public AskDownMsg AskDownMsg { get; set; }

//        [JsonIgnore]
//        [Reactive]
//        public List<bool> IsDowns { get; set; } = new List<bool>();

//        [Reactive] public bool 是否需要寻位 { get; set; } = true;

//        [JsonProperty]
//        [Reactive] public bool 是否使用手动扫码 { get; set; } = false;

//        //[Reactive]
//        //public

//        public FTSSlave()
//        {

//        }



//        /// <summary>
//        /// Mac地址
//        /// </summary>
//        [Reactive] public string MacAddress { get; set; }


//        /// <summary>
//        /// 初始化小车
//        /// </summary>
//        [JsonIgnore]
//        public ReactiveCommand<Unit, Unit> InitCommand => ReactiveCommand.Create(Init);

//        /// <summary>
//        /// 应用到所有站点(统一外观)
//        /// </summary>
//        [JsonIgnore]
//        public ReactiveCommand<Unit, Unit> 应用到所有小车 => ReactiveCommand.Create(() =>
//        {
//            foreach (Car car in ProductLine.Instance.Cars)
//            {
//                if (car == this)
//                {
//                    continue;
//                }

//                if (car is FTSSlave slave)
//                {
//                    slave.CenterBrush = this.CenterBrush;//圆心颜色



//                    slave.Background = this.Background; //背景颜色
//                    slave.XLength = this.XLength;
//                    slave.YLength = this.YLength;

//                    //SlaveCode.
//                    //圆心大小
//                    slave.CenterSize = this.CenterSize;
//                    slave.Fore = this.Fore;//字体颜色
//                    slave.FontSize = this.FontSize;//字体大小

//                    //参考点
//                    slave.OffsetX = this.OffsetX;
//                    slave.OffsetXCoff = this.OffsetXCoff;
//                    slave.OffsetY = this.OffsetY;
//                    slave.RadiusDistance = this.RadiusDistance;

//                    slave.RfChannel = this.RfChannel;// 信道
//                }



//                //car.TypeFaceMaggin = this.TypeFaceMaggin;
//                //station.
//            }
//        });

//        /// <summary>
//        /// 扩展设备
//        /// </summary>
//        [JsonProperty]
//        public ObservableCollection<ICarExtendDevice> ExtendDevices { get; set; } = new ObservableCollection<ICarExtendDevice>();

//        public ReactiveCommand<Unit, Unit> Command创建扩展设备 => ReactiveCommand.Create(() =>
//        {
//            ExtendDevices.Add(new CarExtendAxis() { FTSSlave = this });
//        });

//        #region 调试时用的参数

//        /// <summary>
//        /// 触发超时退出 
//        /// </summary>
//        [JsonIgnore]
//        [Reactive]
//        public bool 触发超时退出 { get; set; } = false;







//        #endregion




//        /// <summary>
//        /// 初始化小车(可多次初始化)
//        /// </summary>
//        public void Init()
//        {
//            foreach (IDisposable mDisposable in m_Disposables)
//            {
//                mDisposable?.Dispose();
//            }
//            m_Disposables.Clear();
//            //小车接收数据
//            m_Disposables.Add(MessageAggregator<byte[]>.Subscribe(ParseData, $"{this.RfChannel}|{this.SoftAddress}"));
//        }

//        /// <summary>
//        /// 注销
//        /// </summary>
//        public void Dispose()
//        {
//            foreach (IDisposable mDisposable in m_Disposables)
//            {
//                mDisposable?.Dispose();
//            }
//            m_Disposables.Clear();

//        }




//        /// <summary>
//        /// 绑定工序
//        /// </summary>
//        [Reactive] public string BindingRoute { get; set; } = "";

//        #region 通讯设定
//        /// <summary>
//        /// 信道
//        /// </summary>
//        [Reactive] public byte RfChannel { get; set; } = 0;

//        /// <summary>
//        /// 通信地址
//        /// </summary>
//        [Reactive] public byte SoftAddress { get; set; } = 0;

//        /// <summary>
//        /// 通信主站(可根据通讯主站名称查询对应的通讯主站)
//        /// </summary>
//        [Reactive] public string MasterName { get; set; } = "";

//        private FTSMaster m_Master;

//        /// <summary>
//        /// 初始化时加入
//        /// </summary>
//        public FTSMaster Master
//        {
//            get => m_Master;
//            set
//            {
//                if (m_Master == value)
//                {
//                    return;
//                }
//                if (m_Master != null)
//                {
//                    if (m_Master.Cars.Contains(this))
//                    {
//                        m_Master.Cars.Remove(this);
//                    }
//                }
//                m_Master = value;
//                if (!m_Master.Cars.Contains(this))
//                {
//                    m_Master.Cars.Add(this);
//                }
//                this.RaisePropertyChanged();
//            }
//        }
//        #endregion



//        #region 运动设定
//        /// <summary>
//        /// 位置缩放比例系数
//        /// </summary>
//        [Reactive]
//        public double PosScale { get; set; } = 1000;

//        /// <summary>
//        /// 速度缩放
//        /// </summary>
//        [Reactive]
//        public double VelScale { get; set; } = 1;

//        #endregion

//        #region 其他设定
//        /// <summary>
//        /// 软件屏蔽(屏蔽后不会给工站到位信号)
//        /// </summary>
//        [Reactive] public bool Shield { get; set; } = false;

//        ///// <summary>
//        ///// 是否移除
//        ///// </summary>
//        //[Reactive]
//        //public bool Removed { get; set; } = false;
//        #endregion



//        /// <summary>
//        /// 驱动器是否通信异常
//        /// </summary>

//        [Reactive]
//        [JsonIgnore]
//        public bool DvLost { get; set; } = true;



//        /// <summary>
//        /// 正限位触发
//        /// </summary>
//        [Reactive]
//        [JsonIgnore]
//        public bool PositiveLimitActive { get; set; } = false;

//        /// <summary>
//        /// 负限位触发
//        /// </summary>
//        [Reactive]
//        [JsonIgnore]
//        public bool NegativeLimitActive { get; set; } = false;

//        //private HomeState? homeState;






//        /// <summary>
//        /// 小车报警数量
//        /// </summary>
//        [Reactive]
//        [JsonIgnore]
//        public int WrnCount { get; set; } = 0;





//        ///// <summary>
//        ///// 小车当前位置
//        ///// </summary>
//        //[Reactive]
//        //public double Position { get; set; } = Double.NaN;





//        /// <summary>
//        /// 驱动程序是否在扫描
//        /// </summary>
//        [Reactive]
//        [JsonIgnore]
//        public bool ScaningDriver { get; set; } = false;

//        /// <summary>
//        /// 驱动器失联报警次数
//        /// </summary>
//        [JsonIgnore]
//        [Reactive] public int DvLostAlarmCount { get; set; }

//        /// <summary>
//        /// 连续出现原点无的次数(超过6次认为小车已经完成与驱动器的通信)
//        /// </summary>
//        [JsonIgnore]
//        [Reactive] public int HomeLostCount { get; set; }

//        /// <summary>
//        /// 复位失联次数
//        /// </summary>
//        [JsonIgnore]
//        [Reactive] public int LostTimes { get; set; }


//        /// <summary>
//        /// 复位失联次数
//        /// </summary>
//        [JsonIgnore]
//        [Reactive] public int LostTimesCopy { get; set; }

//        /// <summary>
//        /// 在超过 10次 50次 100次 时分别记录日志 
//        /// </summary>
//        /// <param name="lostTimes"></param>
//        /// <param name="value"></param>
//        public void SetLostTimeCopy(int lostTimes, int value)
//        {
//            if (LostTimesCopy == value)
//            {
//                return;
//            }
//            LostTimesCopy = value;
//            LogHelp.AddLog<HighWarnLogEntity>($"小车{this.Name} 连续{lostTimes}次通讯失联 {Position} {CurrentLocation?.Position}");
//        }

//        /// <summary>
//        /// 使能无效次数(连续两次未上使能才认为真正没有上使能)
//        /// </summary>
//        [JsonIgnore]
//        [Reactive] public int InactiveCount { get; set; }






//        public void ReadState()
//        {

//        }

//        public void Log(string message)
//        {

//        }

//        /// <summary>
//        /// 查询状态(读取报警状态)
//        /// </summary>
//        /// <param name="error"></param>
//        public void CMD_ReadStatus(out string error)
//        {
//            //CQ位移
//            ReceivedBits <<= 1;
//            byte[] result = Request(FTSCommand.查询状态, out error);
//            if (string.IsNullOrEmpty(error) && result != null)
//            {
//                //查询状态,这里最好为定时任务
//                ParseData(result);
//            }
//            else
//            {

//                //将单次通讯失联的原因找到
//                LostTimes++;
//                if (CommonSetVM.Instance.是否记录单次通讯失联)
//                {
//                    LogHelp.AddLog<WarnLogEntity>($"小车{this.Name} 单次通讯失联 {error}");
//                }

//                if (LostTimes > CommonSetVM.Instance.SlaveLostMaxTime)
//                {
//                    //失联次数过长报警(不能一直报警,否则页面会卡死)
//                    if (LostTimes > CommonSetVM.Instance.SlaveLostMaxTime + CommonSetVM.Instance.SlaveLostMaxTime)
//                    {
//                        LostTimes = CommonSetVM.Instance.SlaveLostMaxTime;
//                        //自动模式暂停时不报警
//                        if (ProductLine.Instance.IsAutoRuning)
//                        {
//                            //自动模式才报警、非自动模式不报警(消息只需要发一条,多条是浪费)
//                            MessageAggregator<ErrorMsg>.Publish($"小车{this.Name} 当前失联次数为 {LostTimes} 超过最大允许失联次数{CommonSetVM.Instance.SlaveLostMaxTime} {error}   当前位置 {Position} {CurrentLocation?.Position}");
//                            //SetAlarm(AlarmCode.DEVICE_LOST, error);
//                        }

//                        if (ProductLine.Instance.IsMasual)
//                        {
//                            //自动模式才报警、非自动模式不报警(消息只需要发一条,多条是浪费)
//                            MessageAggregator<ErrorMsg>.Publish($"小车{this.Name} 当前失联次数为 {LostTimes} 超过最大允许失联次数{CommonSetVM.Instance.SlaveLostMaxTime} {error}   当前位置 {Position} {CurrentLocation?.Position}");
//                            //SetAlarm(AlarmCode.DEVICE_LOST, error);
//                        }
//                    }

//                }
//                else
//                {
//                    //

//                }

//                if (LostTimes >= 100)
//                {
//                    SetLostTimeCopy(LostTimes, 100);
//                }
//                else if (LostTimes >= 50)
//                {
//                    SetLostTimeCopy(LostTimes, 50);
//                    return;
//                }
//                else if (LostTimes >= 10)
//                {
//                    SetLostTimeCopy(LostTimes, 10);
//                }
//                else
//                {
//                    SetLostTimeCopy(LostTimes, 0);
//                }
//            }

//            //统计连通率
//            FillRxValidRate();
//        }

//        public FTS_Result CMD_ReadStatus()
//        {
//            FTS_Result ftsResult = new FTS_Result();
//            byte[] result = Request(FTSCommand.查询状态, out string error);
//            ftsResult.Bytes = result;
//            ftsResult.Error = error;
//            if (string.IsNullOrEmpty(error) && result != null)
//            {
//                //查询状态,这里最好为定时任务
//                ParseData(result);
//            }
//            else
//            {
//                LogHelp.AddLog<WarnLogEntity>($"小车{this.Name} 单次通讯失联");
//                if (LostTimes > CommonSetVM.Instance.SlaveLostMaxTime)
//                {
//                    //失联次数过长报警
//                    MessageAggregator<ErrorMsg>.Publish($"小车{this.Name} 失联 {error}");
//                    SetAlarm(AlarmCode.DEVICE_LOST, error);
//                }
//                else
//                {
//                    //
//                    LostTimes++;
//                }
//            }

//            return ftsResult;

//        }

//        public ReactiveCommand<Unit, Unit> CommandReturnZero => ReactiveCommand.Create(() =>
//        {
//            if (ProductLine.Instance.IsEmergencyStop)
//            {
//                MessageBoxService.Show($"当前状态为急停 不能进行回零");
//                return;
//            }

//            FTS_Result ftsResult = Retry.Try(() => Request(FTSCommand.启动回零), 30);
//            if (!string.IsNullOrEmpty(ftsResult.Error))
//            {
//                MessageBoxService.Show($"回零失败 {ftsResult.Error}");
//            }
//            else
//            {
//                MessageBoxService.Show("回零成功");
//            }
//        });

//        public ReactiveCommand<Unit, Unit> CommandRet => ReactiveCommand.Create(() =>
//        {
//            FTS_Result ftsResult = Retry.Try(() => Request(FTSCommand.清除报警), 30);
//            if (!string.IsNullOrEmpty(ftsResult.Error))
//            {
//                MessageBoxService.Show("复位失败");
//            }
//            else
//            {
//                MessageBoxService.Show("复位成功");
//            }
//        });

//        public ReactiveCommand<Unit, Unit> CommandReStart => ReactiveCommand.Create(() =>
//        {
//            FTS_Result ftsResult = Retry.Try(() => Request(FTSCommand.重启从站), 30);
//            if (!string.IsNullOrEmpty(ftsResult.Error))
//            {
//                MessageBoxService.Show("重启失败");
//            }
//            else
//            {
//                MessageBoxService.Show("重启成功");
//            }
//        });

//        //public ReactiveCommand<Unit, Unit> Command寻位 => ReactiveCommand.Create(() =>
//        //{
//        //    FTS_Result result = ConfirmCarLocation();
//        //    if (!string.IsNullOrEmpty(result.Error))
//        //    {
//        //        MessageBoxService.Show("寻位失败");
//        //    }
//        //    else
//        //    {
//        //        MessageBoxService.Show("寻位成功");
//        //    }
//        //});

//        /// <summary>
//        /// 扫码
//        /// </summary>
//        [JsonIgnore]
//        public ReactiveCommand<FrameworkElement, Unit> CommandScan => ReactiveCommand.Create<FrameworkElement>((control) =>
//        {
//            control.IsEnabled = false;
//            Task.Run(() =>
//            {
//                try
//                {
//                    Request(FTSCommand.启动扫码);
//                    bool isSuccess = false;
//                    for (var i = 0; i < 3000; i++)
//                    {
//                        var ftsResult = RetryFunc.Try(() => CMD_GetLastScanCode(), 100);
//                        if (!string.IsNullOrWhiteSpace(ftsResult.Result))
//                        {
//                            MessageBox.Show(ftsResult.Result);
//                            isSuccess = true;
//                            this.CodeToScan = ftsResult.Result;
//                            break;
//                        }
//                    }

//                    if (!isSuccess)
//                    {
//                        MessageBox.Show("未获取到码");
//                    }
//                }
//                catch (Exception ex)
//                {
//                    MessageBox.Show(ex.Message);
//                }
//                finally
//                {
//                    control.Dispatcher.Invoke(() =>
//                    {
//                        control.IsEnabled = true;
//                    });
//                }
//            });

//        });

//        //public void CmdAbordHome()
//        //{
//        //    Trace.WriteLine($"{this} abort home");
//        //    await master.CMD_AbordHome(RfChannel, softAddress);
//        //}

//        /// <summary>
//        /// 回零
//        /// </summary>
//        /// <param name="isGoHome"></param>
//        /// <param name="error"></param>
//        public void CmdHome(bool isGoHome, out string error)
//        {
//            string op = isGoHome ? "启动" : "停止";
//            LogHelp.AddLog<FtpCarLog>($"{Name} {op}回零");
//            if (isGoHome)
//            {
//                Master.RequestSlave(FTSCommand.启动回零, RfChannel, SoftAddress, out error, null);
//            }
//            else
//            {
//                Master.RequestSlave(FTSCommand.停止回零, RfChannel, SoftAddress, out error, null);
//            }
//        }



//        /// <summary>
//        /// 上使能
//        /// </summary>
//        /// <param name="error"></param>
//        public void CmdEnable(out string error)
//        {
//            //小车上使能
//            LogHelp.AddLog<FtpCarLog>($"{Name} CmdEnable");
//            Master.RequestSlave(FTSCommand.使能, this.RfChannel, this.SoftAddress, out error);
//        }

//        /// <summary>
//        /// 下使能
//        /// </summary>
//        /// <param name="error"></param>
//        public void CmdDisable(out string error)
//        {
//            LogHelp.AddLog<FtpCarLog>($"{Name} CmdEnable");
//            Master.RequestSlave(FTSCommand.断使能, this.RfChannel, this.SoftAddress, out error);
//        }

//        /// <summary>
//        /// 小车绝对运动(对外接口)
//        /// </summary>
//        /// <param name="pos">位置</param>
//        /// <param name="speed">速度</param>
//        public void CmdMoveAbs(double pos, int speed, out string error)
//        {
//            LogHelp.AddLog<FtpCarLog>($"{Name} moveabs {pos} {speed}");
//            pos = (pos) * PosScale + SoftOffset * PosScale;
//            speed = (int)(speed * VelScale);
//            var buffer = new byte[10];
//            var len = 0;
//            var v = (Int64)pos;
//            Utils.Int64ToBytes(v, buffer, len);
//            len += 8;
//            buffer[len++] = (byte)speed;
//            buffer[len++] = (byte)(speed >> 8);
//            Master.RequestSlave(0x47, this.RfChannel, SoftAddress, out error, buffer);
//            //这里运动成功了才能
//        }

//        /// <summary>
//        /// 小车绝对运动(对外接口)
//        /// </summary>
//        /// <param name="pos">位置</param>
//        /// <param name="speed">速度</param>
//        public FTS_Result CmdMoveAbs(double pos, int speed)
//        {
//            if (CommonSetVM.Instance.IsVisual)
//            {
//                base.MoveAbs(pos, speed);
//                return new FTS_Result();
//            }
//            FTS_Result ftsResult = new FTS_Result();
//            LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"moveabs {pos} {speed}") { CarName = this.Name });
//            pos = (pos) * PosScale + SoftOffset * PosScale;
//            speed = (int)(speed * VelScale);
//            var buffer = new byte[10];
//            var len = 0;
//            var v = (Int64)pos;
//            Utils.Int64ToBytes(v, buffer, len);
//            len += 8;
//            buffer[len++] = (byte)speed;
//            buffer[len++] = (byte)(speed >> 8);
//            ftsResult.Bytes = Master.RequestSlave(0x47, this.RfChannel, SoftAddress, out string error, buffer);
//            ftsResult.Error = error;
//            return ftsResult;
//            //这里运动成功了才能
//        }

//        /// <summary>
//        /// 小车绝对运动(对外接口)
//        /// </summary>
//        /// <param name="pos">位置</param>
//        /// <param name="speed">速度</param>
//        public FTS_Result CmdMoveAbs(long intPose, int speed)
//        {
//            if (CommonSetVM.Instance.IsVisual)
//            {
//                base.MoveAbs((double)intPose / PosScale, speed);
//                return new FTS_Result();
//            }
//            FTS_Result ftsResult = new FTS_Result();
//            LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"moveabs {intPose / PosScale} {speed}") { CarName = this.Name });
//            double douPos = intPose + SoftOffset * PosScale;//位置
//            speed = (int)(speed * VelScale);
//            var buffer = new byte[10];
//            var len = 0;
//            var v = (Int64)douPos;
//            Utils.Int64ToBytes(v, buffer, len);
//            len += 8;
//            buffer[len++] = (byte)speed;
//            buffer[len++] = (byte)(speed >> 8);
//            ftsResult.Bytes = Master.RequestSlave(0x47, this.RfChannel, SoftAddress, out string error, buffer);
//            ftsResult.Error = error;
//            return ftsResult;
//            //这里运动成功了才能
//        }


//        /// <summary>
//        /// 小车相对运动
//        /// </summary>
//        /// <param name="speed"></param>
//        public void CmdJogPositive(double pos, int speed, out string error)
//        {
//            LogHelp.AddLog<FtpCarLog>($"{this} moveinc {pos} {speed}");

//            var buffer = new byte[10];
//            var len = 0;
//            var v = (Int64)pos;
//            Utils.Int64ToBytes(v, buffer, len);
//            len += 8;
//            buffer[len++] = (byte)speed;
//            buffer[len++] = (byte)(speed >> 8);
//            Master.RequestSlave(FTSCommand.相对运动, RfChannel, SoftAddress, out error, buffer);
//        }

//        /// <summary>
//        /// 停止运动
//        /// </summary>
//        /// <param name="error"></param>
//        public void CMD_Stop(out string error)
//        {
//            Master.RequestSlave(FTSCommand.停止运动, RfChannel, SoftAddress, out error);
//        }

//        /// <summary>
//        /// 控制扩展设备
//        /// </summary>
//        /// <param name="extendId"></param>
//        /// <param name="extendCmd"></param>
//        /// <param name="content"></param>
//        /// <returns></returns>
//        public FTS_Result CmdControlExtendDevice(byte extendId, CarExtendDeviceControlCommand extendCmd, byte[] content = null)
//        {
//            content = content ?? new byte[0];
//            var newContent = new byte[content.Length + 2];
//            newContent[0] = extendId;
//            newContent[1] = (byte)extendCmd;
//            for (var i = 0; i < content.Length; i++)
//            {
//                newContent[i + 2] = content[i];
//            }
//            FTS_Result result = new FTS_Result();

//            result.Bytes = Master.RequestSlave(FTSCommand.控制扩展设备, RfChannel, SoftAddress, out string error, newContent);
//            result.Error = error;
//            return result;
//        }

//        /// <summary>
//        /// 设置偏移量
//        /// </summary>
//        /// <param name="offset"></param>
//        /// <param name="error"></param>
//        public FTS_Result CmdSetHomeOffset(double offset)
//        {
//            FTS_Result result = new FTS_Result();
//            double setValue = offset * PosScale;
//            LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"{this} set offset:{offset} PosScale:{PosScale}  RealValue:{setValue}") { CarName = this.Name });
//            var content = new byte[4];
//            var v = (int)setValue;
//            Utils.Int32ToBytes(v, content, 0);
//            result.Bytes = Master.RequestSlave(FTSCommand.设置偏移量, RfChannel, SoftAddress, out string error, content);
//            result.Error = error;
//            return result;
//        }

//        /// <summary>
//        /// 设置偏移量
//        /// </summary>
//        /// <param name="offset"></param>
//        /// <param name="error"></param>
//        public void CmdSetHomeOffset(double offset, out string error)
//        {
//            double setValue = offset * PosScale;
//            LogHelp.AddLog<FtpCarLog>($"{this} set offset:{offset} PosScale:{PosScale}  RealValue:{setValue}");
//            var content = new byte[4];
//            var v = (int)setValue;
//            Utils.Int32ToBytes(v, content, 0);
//            Master.RequestSlave(FTSCommand.设置偏移量, RfChannel, SoftAddress, out error, content);
//        }

//        public void CmdSetDO(byte di, byte value, out string error)
//        {
//            error = "";
//            var content = new byte[2];
//            content[0] = di;
//            content[1] = value;
//            FTS_Result ftsResult = this.Request(FTSCommand.设置单路DO输出, content);
//            //this.Request(FTSCommand.设置单路DO输出, content);
//            //Master.RequestSlave(FTSCommand.设置单路DO输出, RfChannel, SoftAddress, out error, content);
//        }

//        public override FTS_Result CmdSetDO(byte di, byte value)
//        {
//            //设置Di
//            if (CommonSetVM.Instance.IsVisual)
//            {
//                return base.CmdSetDO(di, value);
//            }
//            var content = new byte[2];
//            content[0] = di;
//            content[1] = value;
//            return this.Request(FTSCommand.设置单路DO输出, content);
//        }



//        /// <summary>
//        /// 清除报警
//        /// </summary>
//        /// <returns></returns>
//        public void CmdClearFaults(out string error)
//        {
//            LogHelp.AddLog<FtpCarLog>($"{this} clear faults");
//            Request(FTSCommand.清除报警, out error);

//        }

//        /// <summary>
//        /// 驱动器透传(将内容直接发送到驱动器)
//        /// </summary>
//        /// <param name="buffer"></param>
//        /// <param name="error"></param>
//        /// <returns></returns>
//        public byte[] CmdWriteDirectBuffer(byte[] buffer, out string error)
//        {
//            return Master.RequestSlave(FTSCommand.直接发送数据到驱动器, RfChannel, SoftAddress, out error, buffer, 220);
//        }

//        public string CMD_GetLastScanCode(out string error)
//        {
//            var ret = Request(FTSCommand.读取扫码结果, out error);
//            if (ret.Length > 0)
//                return Encoding.ASCII.GetString(ret);
//            return null;
//        }

//        public FTS_Result<string> CMD_GetLastScanCode()
//        {
//            FTS_Result<string> ftsResult = new FTS_Result<string>();
//            ftsResult.Result = "";
//            //使用手动扫码时
//            if (this.是否使用手动扫码)
//            {
//                ftsResult.Result = this.CodeToScan;
//            }
//            else
//            {
//                var ret = Request(FTSCommand.读取扫码结果, out string error);
//                ftsResult.Error = error;

//                if (ret != null && ret.Length > 0)
//                {
//                    ftsResult.Result = Encoding.ASCII.GetString(ret);
//                }
//            }
           


//            return ftsResult;
//        }

//        public byte[] Request(FTSCommand fTSCommand, out string error, byte[] content, byte rfWindow = 5)
//        {
//            return Master.RequestSlave(fTSCommand, RfChannel, SoftAddress, out error, content);
//        }

//        public FTS_Result Request(FTSCommand fTSCommand, byte[] content, byte rfWindow = 5)
//        {
//            FTS_Result result = new FTS_Result();
//            result.Bytes = Master.RequestSlave(fTSCommand, RfChannel, SoftAddress, out string error, content);
//            result.Error = error;
//            return result;
//        }

//        public byte[] Request(FTSCommand fTSCommand, out string error)
//        {
//            return Master.RequestSlave(fTSCommand, RfChannel, SoftAddress, out error, rfWindow: Master.SlaveResponseWindow);
//        }

//        public FTS_Result Request(FTSCommand fTSCommand)
//        {
//            if (CommonSetVM.Instance.IsVisual)
//            {
//                return new FTS_Result();
//            }
//            LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"执行: {fTSCommand} 命令") { CarName = Name });
//            FTS_Result result = new FTS_Result();
//            result.Bytes = Master.RequestSlave(fTSCommand, RfChannel, SoftAddress, out string error);
//            result.Error = error;
//            return result;
//        }



//        /// <summary>
//        /// 解析数据(此处将下位机从站数据更新到小车)
//        /// </summary>
//        /// <param name="data"></param>
//        public void ParseData(byte[] content)
//        {
//            try
//            {
//                PressData();
//            }
//            catch (Exception e)
//            {
//                if (LostTimes > CommonSetVM.Instance.SlaveLostMaxTime)
//                {
//                    //失联次数超过200次,失联报警
//                    SetAlarm(AlarmCode.DEVICE_LOST, e);
//                }
//                else
//                {
//                    LostTimes++;
//                }
//            }

//            void PressData()
//            {
//                BitArray bitArray = new BitArray(content[0..1]);
//                //解析driver lost 
//                var home = bitArray[4];

//                //var home2 = (content[0] & 0x10) != 0;

//                var carInited = false;//原点状态(在原点说明 小车没有完成与驱动器的通讯,完成通信就不在原点)
//                if (home)
//                {
//                    HomeLostCount = 0;
//                    carInited = true;//todo 岳志峰 我想此处应该为false(暂时先不动) 
//                }
//                else
//                {
//                    if (HomeLostCount > 6)  //连续出现原点无的时候，才认为小车已经完成与驱动器的通信
//                    {
//                        carInited = true;
//                    }
//                    else
//                    {
//                        HomeLostCount++;
//                    }
//                }

//                //小车未完成与驱动器的通信
//                if (!carInited)
//                {
//                    return;
//                }

//                // 连续两次使能无效才认为未使能
//                var active = bitArray[1];
//                if (active)
//                {
//                    Active = true;
//                    InactiveCount = 0;
//                }
//                else if (InactiveCount > 1)
//                {
//                    Active = false;
//                }
//                else
//                {
//                    InactiveCount++;
//                }


//                LostTimes = 0;  //复位失联次数
//                DvLost = bitArray[0];
//                PositiveLimitActive = bitArray[2];
//                NegativeLimitActive = bitArray[3];
//                if (bitArray[4])
//                {
//                    HomeState = HomeState.Completed;
//                }
//                else
//                {
//                    HomeState = HomeState.Idle;
//                }

//                if (bitArray[5])
//                {
//                    Status = CarStatus.Stopped;
//                }
//                else
//                {
//                    Status = CarStatus.Moving;
//                }

//                //Status = (content[0] & 0x20) == 0 ? CarStatus.Moving : CarStatus.Stopped;
//                //WrnCount = (content[0] & 0x40) == 0 ? 0 : 1;
//                if (bitArray[6])
//                {
//                    WrnCount = 1;
//                }
//                else
//                {
//                    WrnCount = 0;
//                }
//                WrnCount = bitArray[6] ? 1 : 0;
//                //ScaningDriver = (content[0] & 0x80) != 0;
//                ScaningDriver = bitArray[7];
//                Position = (double)Utils.BytesToInt64(content, 2) / PosScale - SoftOffset;

//                DigitInOut = content[1];//数字输入输出
//                DigitInputState = (byte)(content[1] & 0x0f);
//                DigitOutputState = (byte)(content[1] >> 4);

//                if (content.Length >= 11)
//                {
//                    RxRSSI = content[10];
//                }

//                if (content.Length >= 12)
//                {
//                    DrvLostTimes = ((int)content[12] << 8) | content[11];
//                }


//                //有效通信一次
//                ReceivedBits |= 0x01;
//                if (DvLostAlarmCount == 0 && DvLost)
//                {
//                    Log(System.BitConverter.ToString(content));
//                }

//                if (WrnCount > 0)
//                {
//                    SetAlarm(AlarmCode.DEVICE_ALARM);
//                }

//                if (DvLost)
//                {
//                    if (DvLostAlarmCount > 5)
//                    {
//                        SetAlarm(AlarmCode.CAR_DRIVE_LOST);
//                    }
//                    else
//                    {
//                        DvLostAlarmCount++;
//                    }
//                }
//                else if (DvLostAlarmCount > 0)
//                {
//                    DvLostAlarmCount = 0;
//                }

//                ////统计连通率
//                //FillRxValidRate();

//                for (var i = 0; i < this.ExtendDevices.Count; i++)
//                {
//                    var extendDevice = this.ExtendDevices[i];

//                    try
//                    {
//                        var res = this.CmdGetExtendDeviceStatusList((byte)i, 1).Result;
//                        if (res == null)
//                        {
//                            continue;
//                        }
//                        if (extendDevice is CarExtendAxis extendAxis)
//                        {
//                            // TODO: 匹配id
//                            extendAxis.Position = (double)Utils.BytesToInt32(res[0].Content, 0);

//                            extendAxis.Connected = (res[0].State & SlaveExtendDeviceStateBit.CONNECTED) != 0;
//                            extendAxis.Active = (res[0].State & SlaveExtendDeviceStateBit.ACTIVE) != 0;
//                            extendAxis.HomeState = (res[0].State & SlaveExtendDeviceStateBit.HOME) != 0 ? HomeState.Completed : HomeState.Idle;
//                            extendAxis.Status = (res[0].State & SlaveExtendDeviceStateBit.MOVING) != 0 ? CarStatus.Moving : CarStatus.Stopped;
//                            extendAxis.NegativeLimitActive = (res[0].State & SlaveExtendDeviceStateBit.NEGATIVE_LIMIT) != 0;
//                            extendAxis.PositiveLimitActive = (res[0].State & SlaveExtendDeviceStateBit.POSITIVE_LIMIT) != 0;
//                            if ((res[0].State & SlaveExtendDeviceStateBit.ALARM) != 0)
//                                extendAxis.SetAlarm(AlarmCode.DEVICE_ALARM);
//                        }
//                    }
//                    catch (Exception ex)
//                    {
//                        ErrorLogEntity errorLogEntity = new ErrorLogEntity($"小车{Name}扩展设备异常", ex);
//                        LogHelp.AddLog<ErrorLogEntity>(errorLogEntity);
//                    }

//                }
//            }


//        }

//        /// <summary>
//        /// 统计连通率(此处使用位移法)
//        /// </summary>
//        /// <returns></returns>
//        public void FillRxValidRate()
//        {
//            var validCount = 0;
//            //统计连通率
//            for (var k = 0; k < sizeof(ulong) * 8; k++)
//            {
//                if ((ReceivedBits & (1UL << k)) != 0)
//                    validCount++;
//            }
//            RxValidRate = validCount * 100 / (sizeof(ulong) * 8);
//        }

//        public void SetAlarm(AlarmCode code, Exception exception)
//        {
//            var exp = exception;
//            while (exp.InnerException != null)
//                exp = exp.InnerException;
//            SetAlarm(code, exp.Message);
//        }

//        public void SetAlarm(AlarmCode code, string detail = null)
//        {
//            MessageAggregator<ErrorMsg>.Publish($"小车{this.Name}  {code.GetDescription()}");
//            //var alarms = Alarms.ToArray();
//            //if (alarms.Any(m => m != null && m.Device == this && m.AlarmCode == code && m.Detail == detail))
//            //    return;
//            //Alarms.Add(new AlarmRecord(this, code, detail));
//            //Trace.WriteLine($"{this} 报警: {code}, {detail}");
//            //if (this is Car car)
//            //{
//            //    Trace.WriteLine($"{car.Active}|{car.Status}|{car.DvLost}|{car.Position}|{car.HomeState}|DLC:{car.DrvLostTimes}");
//            //}
//        }

//        /// <summary>
//        /// 确定小车在哪个导轨(寻位)
//        /// </summary>
//        /// <param name="fSSlave"></param>
//        public override FTS_Result ConfirmCarLocation()
//        {
//            FTS_Result ftsResult = new FTS_Result();
//            //无需寻位直接走
//            if (!this.是否需要寻位)
//            {
//                this.Located = false;
//                return ftsResult;
//            }
//            //寻位会将MoveOffset置为0
//            this.MoveOffset = 0;

//            //急停的时候
//            if (ProductLine.Instance.IsEmergencyStop)
//            {
//                ftsResult.Error = "当前急停触发,不能寻位";
//                return ftsResult;
//            }
//            //处理虚拟
//            if (CommonSetVM.Instance.IsVisual)
//            {
//                return base.ConfirmCarLocation();
//            }

//            FTSSlave car = this;
//            LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"开始寻位") { CarName = this.Name });
//            //Trace.WriteLine($"{car} 寻位");
//            if (!car.Active)
//            {
//                LogHelp.AddLog<FtpCarLog>($"{car.Name} 没有使能 中止寻位");
//                ftsResult.Error = $"{car.Name} 没有上使能 中止寻位";
//                return ftsResult;
//            }
//            car.Located = false;

//            //通信异常
//            if (car.DvLost)
//            {
//                for (int i = 0; i < 3; i++)
//                {
//                    //重启从站
//                    FTS_Result ftsRestart = Retry.Try(() => Request(FTSCommand.重启从站), 30);
//                    if (!string.IsNullOrEmpty(ftsResult.Error))
//                    {

//                        //MessageBoxService.Show("重启失败");
//                    }
//                    else
//                    {
//                        //MessageBoxService.Show("重启成功");
//                    }
//                    Thread.Sleep(500);
//                    if (!car.DvLost)
//                    {
//                        break;
//                    }
//                }

//                //驱动器异常
//                if (car.DvLost)
//                {
//                    ftsResult.Error = $"{car.Name} 与驱动器通讯异常,请断开小车电源后重启";
//                    //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                    return ftsResult;
//                }


//            }




//            // 确定附近的Z信号，如果刚好越过Z信号（不超过0.1mm)，则回退1mm后进行回零
//            var curPos = car.Position;
//            if (Math.Abs((curPos + car.SoftOffset) % (CommonSetVM.Instance.MagnentPolarLength * (double)CommonSetVM.Instance.CarHomeDirection)) <= 0.5)
//            {
//                var tgtPos = curPos - 1 * (double)CommonSetVM.Instance.CarHomeDirection;
//                Retry.Try(() =>
//                {
//                    return car.CmdMoveAbs(tgtPos, 20);
//                }, 30);

//                //重复操作直到超时退出
//                //等待设备移动完毕
//                DateTime startTime = DateTime.Now;
//                while (true)
//                {
//                    ProductLine.Instance.Sleep(50);
//                    if (car.Status != CarStatus.Moving && Math.Abs(car.Position - tgtPos) < 0.1)
//                    {
//                        break;
//                    }

//                    //超时退出
//                    TimeSpan ts = DateTime.Now - startTime;
//                    if (ts.TotalMilliseconds > 3000)
//                    {
//                        ftsResult.Error = $"{car.Name} 寻位移动超时";
//                        car.MoveStop();//停止移动
//                        //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                        return ftsResult;
//                    }

//                    //急停(寻位时发生急停) 直接退出
//                    if (ProductLine.Instance.IsEmergencyStop)
//                    {
//                        ftsResult.Error = $"{car.Name} 寻位移动超时遇到急停从而退出";
//                        //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                        return ftsResult;
//                    }
//                }
//            }

//            Thread.Sleep(200);

//            //清除原点
//            var retStopHome = Retry.Try(() => car.Request(FTSCommand.停止回零), 100).Error;
//            if (!string.IsNullOrEmpty(retStopHome))
//            {
//                ftsResult.Error = $"小车:{car.Name} 寻位过程中清除原点失败";
//                //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                return ftsResult;
//            }
//            Thread.Sleep(200);
//            //等待原点清除
//            string retClearHome = Retry.WaitUntil(() => car.HomeState == HomeState.Idle, 8000, 0);
//            if (!string.IsNullOrEmpty(retClearHome))
//            {
//                ftsResult.Error = $"小车:{car.Name} 寻位过程中清除原点状态异常 原点状态为 {car.HomeState}  {retClearHome}";
//                //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                return ftsResult;
//            }

//            //开始回零
//            var goHomeRet = Retry.Try(() => car.Request(FTSCommand.启动回零), 20).Error;
//            if (!string.IsNullOrEmpty(goHomeRet))
//            {
//                ftsResult.Error = $"小车:{car.Name} 寻位过程中 进行启动回零异常 {goHomeRet}";
//                //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                return ftsResult;
//            }

//            //等待回零完成
//            var retGoHomeComplete = Retry.WaitUntil(() => car.HomeState == HomeState.Completed && car.Status != CarStatus.Moving, 8000, 1000);
//            if (!string.IsNullOrEmpty(retGoHomeComplete))
//            {
//                ftsResult.Error = $"小车:{car.Name} 寻位过程中 进行等待回零完成异常 {retGoHomeComplete} 当前状态为{car.HomeState}";
//                //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                return ftsResult;
//            }

//            //启动扫码

//            Thread.Sleep(200);

//            var ret启动扫码 = Retry.Try(() => car.Request(FTSCommand.启动扫码), 20).Error;
//            if (!string.IsNullOrEmpty(ret启动扫码))
//            {
//                ftsResult.Error = $"小车:{car.Name} 寻位过程中 启动扫码异常 {ret启动扫码}";
//                //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                return ftsResult;
//            }

//            //获取位置
//            var retStates = Retry.Try(() => car.CMD_ReadStatus(), 20);
//            if (!string.IsNullOrEmpty(retStates.Error))
//            {
//                ftsResult.Error = $"小车:{car.Name} 寻位过程中 获取位置异常 {retStates.Error}";
//                //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                return ftsResult;
//            }

//            var pos = (double)Utils.BytesToInt64(retStates.Bytes, 2) / car.PosScale - car.SoftOffset;
//            string code = null;

//            Thread.Sleep(300);
//            //扫码

//            List<int> lisOffsets = new List<int>();
//            double distance = car.Position;
//            lisOffsets.Add(0);
//            if (CommonSetVM.Instance.启用偏移扫码)
//            {
//                for (int i = 1; i <= CommonSetVM.Instance.扫码范围; i++)
//                {
//                    lisOffsets.Add(-i);
//                    lisOffsets.Add(i);
//                }
//            }

//            bool haveSancCode = false;
//            foreach (int Offset in lisOffsets)
//            {
//                if (Offset != 0)
//                {
//                    MovePosition(car, distance + Offset);
//                }
//                code = this.扫码并校验结果(out string error);
//                //if (Offset == 0)
//                //{
//                //    code = "";
//                //}

//                if (!string.IsNullOrEmpty(error))
//                {
//                    ftsResult.Error = error;
//                    //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                    return ftsResult;
//                }

//                if (!string.IsNullOrEmpty(code))
//                {
//                    //移动到指定位置(并等待完成)
//                    LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"小车扫码完成  Code {code} 将移动至{pos - 0.5 * (int)CommonSetVM.Instance.CarHomeDirection}") { CarName = car.Name });

//                    MovePosition(car, pos - 0.5 * (int)CommonSetVM.Instance.CarHomeDirection, 30);
//                    ////扫到码了 反方向运动0.5mm
//                    //var moveResultNear = Retry
//                    //    .Try(() => car.CmdMoveAbs(pos - 0.5 * (int)CommonSetVM.Instance.CarHomeDirection, 5), 30).Error;
//                    //if (!string.IsNullOrEmpty(moveResultNear))
//                    //{
//                    //    ftsResult.Error = $"小车:{car.Name} 寻位过程中 扫码内容为{code}  反方向运动0.5mm异常 {moveResultNear}";
//                    //    //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                    //    return ftsResult;
//                    //}

//                    haveSancCode = true;

//                    ftsResult = SetCode(car, code, Offset);
//                    break;
//                }
//            }

//            if (!haveSancCode)
//            {
//                ftsResult.Error = "寻位扫码失败";
//                return ftsResult;
//            }
//            else if (!string.IsNullOrEmpty(ftsResult.Error))
//            {
//                //计算偏移量失败
//                return ftsResult;
//            }

//            LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"寻位完成") { CarName = this.Name });

//            //LogHelp.AddLog<FtpCarLog>($"寻位完成");
//            return ftsResult;
//        }

//        /// <summary>
//        /// 扫码并获取结果
//        /// </summary>
//        /// <returns></returns>
//        public string 扫码()
//        {
//            FTSSlave car = this;
//            FTS_Result<string> retScanCode = new FTS_Result<string>();
//            for (int i = 0; i <= CommonSetVM.Instance.同一位置扫码次数; i++)
//            {
//                var ret启动扫码 = Retry.Try(() => car.Request(FTSCommand.启动扫码), 20).Error;
//                //if (!string.IsNullOrEmpty(ret启动扫码))
//                //{
//                //    //ftsResult.Error = $"小车:{car.Name} 寻位过程中 启动扫码异常 {ret启动扫码}";
//                //    //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                //    return string.Empty;
//                //}
//                Thread.Sleep(500);
//                retScanCode = Retry.Try(() => car.CMD_GetLastScanCode(), 100);
//                if (!string.IsNullOrEmpty(retScanCode.Result))
//                {
//                    return retScanCode.Result;
//                }

//                if (CommonSetVM.Instance.扫码重启从站)
//                {
//                    Retry.Try(() => car.Request(FTSCommand.重启从站), 30);
//                    Thread.Sleep(3000);
//                }
//            }
//            return string.Empty;
//        }

//        /// <summary>
//        /// 扫码并校验多次扫码结果
//        /// </summary>
//        /// <returns></returns>
//        public string 扫码并校验结果(out string error)
//        {
//            FTSSlave car = this;
//            error = string.Empty;
//            string code = 扫码();
//            if (string.IsNullOrEmpty(code))
//            {
//                return code;
//            }
//            if (!CommonSetVM.Instance.扫码校验)
//            {
//                return code;
//            }

//            //多次扫码校验结果
//            Dictionary<string, int> dic = new Dictionary<string, int>();
//            dic.Add(code, 1);
//            for (int i = 0; i < 6; i++)
//            {
//                string onceRet = 扫码();
//                LogHelp.AddLog<FtpCarLog>(new FtpCarLog($" 扫码结果为：{onceRet} ") { CarName = car.Name });
//                if (string.IsNullOrEmpty(onceRet))
//                {
//                    continue;
//                }
//                else
//                {
//                    if (!dic.ContainsKey(onceRet))
//                    {
//                        dic.Add(onceRet, 0);
//                    }
//                    dic[onceRet]++;
//                }

//                if (dic.Count != 1)
//                {
//                    string rets = "";
//                    foreach (KeyValuePair<string, int> keyValuePair in dic)
//                    {
//                        rets += $"扫码结果 {keyValuePair.Key} 次数{keyValuePair.Value}";
//                    }
//                    LogHelp.AddLog<InitLogEntity>($"小车:{car.Name} 寻位过程中 多次扫码不一致 {rets}");
//                    error = $"小车:{car.Name} 寻位过程中 多次扫码不一致";
//                    return "";
//                }
//                if (dic.Count == 1 && dic[onceRet] >= 3)
//                {
//                    break;
//                }
//            }

//            return code;

//        }

//        private void MovePosition(FTSSlave car, double distance, double speed = 100)
//        {
//            var stopwatch = new Stopwatch();
//            stopwatch.Start();
//            while (true)
//            {
//                bool haveFinished = false;
//                //这里不能异步执行否则就完犊子了
//                Retry.Try(() => CmdMoveAbs(distance, (int)speed), 50);
//                //car.MoveAbs(distance, speed);
//                if (stopwatch.ElapsedMilliseconds > 5000)
//                {
//                    stopwatch.Stop();
//                    MessageAggregator<ErrorMsg>.Publish($"小车{car.Name} 寻位移动超时");
//                    LogHelp.AddLog<ErrorLogEntity>($"小车{car.Name} 寻位移动超时");
//                    car.MoveStop();//发停止指令
//                    //LogHelp.AddLog($"");
//                    return;
//                }
//                while (true)
//                {
//                    Thread.Sleep(300);

//                    if (car.Status != CarStatus.Stopped)
//                    {
//                        continue;
//                    }

//                    double offset = Math.Abs(car.Position - distance);
//                    if (offset < 0.1)
//                    {
//                        haveFinished = true;
//                        break;
//                    }
//                    else
//                    {
//                        break;
//                    }
//                }

//                if (haveFinished)
//                {
//                    break;
//                }
//            }
//        }

//        /// <summary>
//        /// 将扫码结果写入
//        /// </summary>
//        /// <param name="car"></param>
//        /// <param name="code"></param>
//        private FTS_Result SetCode(FTSSlave car, string code, int codeOffset)
//        {
//            FTS_Result ftsResult = new FTS_Result();
//            var num = Convert.ToInt32(String.Join("", code.Where(m => m >= '0' && m <= '9')));
//            ProductLine.Instance.GetCarLocationByQrNum(num, out var passVm, out var offset);
//            //offset = offset + codeOffset;
//            //设置偏移量
//            var setHomeOffset = Retry.Try(() => car.CmdSetHomeOffset(offset), 50).Error;
//            if (!string.IsNullOrEmpty(setHomeOffset))
//            {
//                ftsResult.Error = $"小车:{car.Name} 寻位过程中 设置偏移量:{offset}  异常 {setHomeOffset}";
//                //MessageAggregator<ErrorMsg>.Publish(ftsResult.Error);
//                return ftsResult;
//            }

//            //添加通道
//            if (passVm != null)
//            {
//                passVm.AddCar(car);
//            }
//            car.Located = true;
//            return ftsResult;
//        }


//        #region          override 
//        /// <summary>
//        /// 使能
//        /// </summary>
//        public override FTS_Result Enable()
//        {
//            if (CommonSetVM.Instance.IsVisual)
//            {
//                return base.Enable();
//            }

//            return Retry.Try(() => this.Request(FTSCommand.使能), 100);
//            //if (this.Active)
//            //{
//            //  return  Retry.Try(() => this.Request(FTSCommand.断使能),100);
//            //}
//            //else
//            //{

//            //}
//        }

//        /// <summary>
//        /// 使能
//        /// </summary>
//        public override FTS_Result EnableAndDisable()
//        {
//            if (CommonSetVM.Instance.IsVisual)
//            {
//                return base.EnableAndDisable();
//            }

//            if (this.Active)
//            {
//                return Retry.Try(() => this.Request(FTSCommand.断使能), 100);
//            }
//            else
//            {
//                return Retry.Try(() => this.Request(FTSCommand.使能), 100);
//            }
//        }

//        /// <summary>
//        /// 运动
//        /// </summary>
//        /// <param name="pos"></param>
//        /// <param name="speed"></param>
//        public override void MoveAbs(double pos, double speed)
//        {
//            if (CommonSetVM.Instance.IsVisual)
//            {
//                base.MoveAbs(pos, speed);
//            }
//            else
//            {
//                Task.Run(() =>
//                {
//                    Retry.Try(() => CmdMoveAbs(pos, (int)speed), 50);
//                });
//            }


//        }

//        /// <summary>
//        /// 停止
//        /// </summary>
//        public override void MoveStop()
//        {
//            Task.Run(() =>
//            {
//                Retry.Try(() => CmdMoveStop(), 30);
//            });

//        }

//        public override FTS_Result CmdMoveStop()
//        {
//            LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"小车发送停止命令") { CarName = Name });
//            return Request(FTSCommand.停止运动);
//        }

//        public FTS_Result<SlaveExtendDeviceStatus[]> CmdGetExtendDeviceStatusList(byte startIndex, byte count)
//        {
//            FTS_Result<SlaveExtendDeviceStatus[]> ftsResult = new();
//            if (count == 0)
//            {
//                ftsResult.Error = "扩展设备数量不能为0";
//                return ftsResult;
//            }

//            byte[] inputBytes = new byte[] { startIndex, count };
//            FTS_Result ret = Request(FTSCommand.读取扩展设备状态, inputBytes);
//            if (!string.IsNullOrEmpty(ret.Error))
//            {
//                ftsResult.Error = ret.Error;
//                return ftsResult;
//            }

//            var content = ret.Bytes;
//            var statusList = new SlaveExtendDeviceStatus[count];
//            for (var i = 0; i < count; i++)
//            {
//                statusList[i] = new SlaveExtendDeviceStatus
//                {
//                    ExtendId = content[i * 6],
//                    State = (SlaveExtendDeviceStateBit)content[i * 6 + 1]
//                };
//                Array.Copy(content, i * 6 + 2, statusList[i].Content, 0, 4);
//            }

//            ftsResult.Result = statusList;
//            return ftsResult;
//        }

//        /// <summary>
//        /// 按页下载固件数据
//        /// </summary>
//        /// <param name="page"></param>
//        /// <param name="data">32字节</param>
//        /// <returns></returns>
//        public FTS_Result CmdDownloadFirmwareData(UInt16 page, byte[] data)
//        {
//            var content = new byte[2 + data.Length];
//            content[0] = (byte)page;
//            content[1] = (byte)(page >> 8);
//            Array.Copy(data, 0, content, 2, data.Length);
//            return Request(FTSCommand.OTA下载App数据, content);
//        }

//        public FTS_Result<byte[]> CmdRegesiter(int startAdress, byte[] contentBytes)
//        {
//            var head = new byte[1];
//            head[0] = head[0].SetHigh4Bits((byte)startAdress);//设置高字节
//            int length = contentBytes.Length / 2 - 1;
//            head[0] = head[0].SetLow4Bits((byte)length);//设置低字节
//            var content = head.Mergin(ref contentBytes);
//            string hex = Hex.ToHexString(content);
//            byte[] ret = Request(FTSCommand.读写小车寄存器, out string error, content);
//            FTS_Result<byte[]> ftsResult = new FTS_Result<byte[]>();
//            ftsResult.Error = error;
//            ftsResult.Result = ret;
//            return ftsResult;
//        }



//        /// <summary>
//        /// 下载固件信息
//        /// </summary>
//        /// <param name="rfChannel"></param>
//        /// <param name="slaveAddress"></param>
//        /// <param name="version"></param>
//        /// <param name="note"></param>
//        /// <param name="firmwareDataLength"></param>
//        /// <param name="firmwareDataChksum"></param>
//        /// <returns></returns>
//        public FTS_Result CMD_DownloadSlaveFirmwareInfo(byte[] version, string note, UInt16 firmwareDataLength, byte firmwareDataChksum)
//        {
//            var content = new byte[28];

//            Array.Copy(version, content, 4);

//            var noteBytes = Encoding.UTF8.GetBytes(note);
//            var len = noteBytes.Length > 20 ? 20 : noteBytes.Length;
//            Array.Copy(noteBytes, 0, content, 4, len);
//            content[4 + len] = 0;

//            content[24] = (byte)firmwareDataLength;
//            content[25] = (byte)(firmwareDataLength >> 8);

//            content[26] = (byte)firmwareDataChksum;

//            byte chksum = 0;
//            for (var i = 0; i < 27; i++)
//                chksum += content[i];
//            content[27] = chksum;
//            return Request(FTSCommand.OTA下载App信息, content);
//        }

//        /// <summary>
//        /// 读取固件版本
//        /// </summary>
//        /// <returns></returns>
//        public FTS_Result<string> CmdReadFirmwareVersion()
//        {
//            FTS_Result<string> ftsResult = new FTS_Result<string>();
//            var ret = Request(FTSCommand.读取固件版本, out string error);
//            ftsResult.Error = error;

//            if (ret != null && ret.Length > 0)
//            {
//                ftsResult.Result = Encoding.UTF8.GetString(ret);
//            }
//            return ftsResult;
//        }


//        public override void StopOnce()
//        {
//            if (CommonSetVM.Instance.IsVisual)
//            {
//                base.StopOnce();
//                return;
//            }
//            CmdMoveStop();
//        }

//        #endregion




//        #region 移动相关

//        //public  void MoveInc(Station fromStation, MoveRelation moveRelation, double inc)
//        //{

//        //}

//        public override void MoveStation(Station fromStation, MoveRelation moveRelation, double movePosition, bool isMasual = false, int 速度 = -1)
//        {

//            LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"小车从站点  {fromStation.Name}    ,移动至站点{moveRelation.Station.Name}") { CarName = this.Name });
//            Station endStation = moveRelation.Station;
//            Car car = this;
//            double fromPosition = car.Position;
//            if (fromStation.PassVM != endStation.PassVM)
//            {
//                double beforePosition = fromStation.CurrentCar.Position;
//                double changePassVMPosition = beforePosition + moveRelation.IncFrom;
//                if (moveRelation.PassVmRelation.WayPassVm == null)
//                {
//                    Task.Run(() =>
//                    {
//                        //切换通道
//                        while (true)
//                        {
//                            if (moveRelation.Inc >= 0)
//                            {
//                                if (car.Position >= changePassVMPosition)
//                                {
//                                    break;
//                                }
//                            }
//                            else
//                            {
//                                if (car.Position <= changePassVMPosition)
//                                {
//                                    break;
//                                }
//                            }
//                            Thread.Sleep(20);
//                        }

//                        if (moveRelation.PassVmRelation.IsInByStart)
//                        {
//                            car.ArricePassPosition = 0;
//                        }
//                        else
//                        {
//                            car.ArricePassPosition = endStation.PassVM.TotalLength;
//                        }

//                        car.ArriceCarPosition = changePassVMPosition;
//                        car.PassVM = endStation.PassVM;

//                    });
//                }
//                else
//                {
//                    changePassVMPosition = beforePosition + moveRelation.WayIncFrom;
//                    Task.Run(() =>
//                    {
//                        //切换通道
//                        while (true)
//                        {
//                            if ((moveRelation.WayIncFrom) >= 0)
//                            {
//                                if (car.Position >= changePassVMPosition)
//                                {
//                                    break;
//                                }
//                            }
//                            else
//                            {
//                                if (car.Position <= changePassVMPosition)
//                                {
//                                    break;
//                                }
//                            }
//                            Thread.Sleep(20);
//                        }
//                        //设置当前通道为途径通道
//                        car.PassVM = moveRelation.PassVmRelation.WayPassVm;
//                        double min = moveRelation.PassVmRelation.WayPassVm.StartPosition;
//                        double max = moveRelation.PassVmRelation.WayPassVm.StartPosition + moveRelation.PassVmRelation.WayPassVm.TotalLength;
//                        //途径站点
//                        Thread.Sleep(100);
//                        while (true)
//                        {
//                            if (car.Position < min || car.Position > max)
//                            {
//                                break;
//                            }
//                            Thread.Sleep(20);
//                        }

//                        car.PassVM = endStation.PassVM;
//                    });
//                }

//            }

//            //移动距离
//            endStation.MovePosition = movePosition;

//            if (CommonSetVM.Instance.IsVisual)
//            {
//                base.MoveStation(fromStation, moveRelation, movePosition, isMasual, 速度);
//                return;
//            }
//            Task.Run(() =>
//            {
//                int speed = CommonSetVM.Instance.CarSpeed;
//                if (速度 == -1)
//                {
//                    if (!CommonSetVM.Instance.IsSameSpeed)
//                    {
//                        speed = endStation.Speed;
//                    }

//                    speed = Convert.ToInt32(speed * CommonSetVM.Instance.SpeedlScale * 0.01);

//                    //没有设速度
//                    if (speed == 0 || speed == -1)
//                    {
//                        speed = CommonSetVM.Instance.CarSpeed;
//                    }
//                }
//                else
//                {
//                    speed = 速度;
//                }




//                string operateID = Guid.NewGuid().ToString("N");

//                //小车要去的站点
//                //当前没在移动方可移动
//                while (true)
//                {
//                    if (this.Status == CarStatus.Stopped)
//                    {
//                        break;
//                    }
//                    ProductLine.Instance.Sleep(10);
//                }

//                //理论上的时间(根据理论上的时间进行处理)
//                double theoryTime = Math.Abs(endStation.MovePosition - car.Position) / speed * 1000;
//                double overtime = theoryTime * 3 + 1000;//超时时间
//                DealStop(fromStation, isMasual);
//                double fromPosition = car.Position;
//                //var moveAbsError = Retry.Try(() => this.CmdMoveAbs(endStation.MovePosition, speed), 100).Error;
//                //if (!string.IsNullOrEmpty(moveAbsError))
//                //{
//                //    //抛异常  等外部处理异常  并停止
//                //    MessageAggregator<ErrorMsg>.Publish($"小车Moving {this.Name} 移动至 站点:{endStation.Name}  位置:{endStation.MovePosition} 失败 原因{moveAbsError}");
//                //    fromStation.IsMoveError = true;
//                //    return;
//                //}
//                DateTime startTime = DateTime.Now;
//                DateTime moveTime = DateTime.Now;
//                bool haveMoving = false;
//                //判断小车有没有动起来
//                while (true)
//                {
//                    //处理停止
//                    //DealStop(fromStation, isMasual);

//                    //处理急停
//                    //while (true)
//                    //{
//                    //    if (ProductLine.Instance.IsEmergencyStop)
//                    //    {
//                    //        fromStation.StationState = StationState.系统停止;
//                    //        ProductLine.Instance.Sleep(200);
//                    //        continue;
//                    //    }
//                    //    break;
//                    //}


//                    //小车动起来了()
//                    if (this.Status == CarStatus.Moving)
//                    {
//                        double moveDistance = Math.Abs(car.Position - fromPosition);
//                        //移动超过10毫米 认为小车动了(位置和持续时间 有位置就行)
//                        if (moveDistance > 10)
//                        {
//                            moveTime = DateTime.Now;
//                            haveMoving = true;
//                            break;
//                        }

//                        if (haveMoving == false)
//                        {
//                            moveTime = DateTime.Now;
//                            haveMoving = true;
//                        }
//                        else
//                        {
//                            //需要状态持续100 毫秒才能放行
//                            TimeSpan timeSpan = DateTime.Now - moveTime;
//                            if (timeSpan.TotalMilliseconds > 100)
//                            {
//                                //
//                                //break;
//                            }
//                        }
//                    }
//                    else
//                    {
//                        this.CmdMoveAbs(endStation.MovePosition, speed);
//                        Thread.Sleep(20);
//                        if (haveMoving)
//                        {
//                            //这里不再记录状态变更
//                           // LogHelp.AddLog<HighWarnLogEntity>($"小车Moving{car.Name}从 站点:{fromStation.Name}  位置:{fromPosition}  移动至站点：{endStation.Name} 位置:{endStation.MovePosition} 时,MoveState发生变化 当前位置{car.Position}");
//                            haveMoving = false;
//                        }
//                        continue;
//                    }

//                    //小车快到了(因为小车状态变更机制是主从站连接的,会出现移动瞬间完成的可能,此处增加位置判断作为补充判断)
//                    if (Math.Abs(endStation.MovePosition - car.Position) < CommonSetVM.Instance.ArriveDistance)
//                    {
//                        break;
//                    }


//                    //遇到急停先停止小车 等到急停解除后继续行驶到指定站点
//                    if (ProductLine.Instance.IsEmergencyStop)
//                    {
//                        LogHelp.AddLog<ErrorLogEntity>($"小车{car.Name}从 站点:{fromStation.Name}  位置:{fromPosition}  移动至站点：{endStation.Name} 位置:{endStation.MovePosition} 被急停打断");
//                        //急停 让小车停下来
//                        while (true)
//                        {
//                            var stopMsg = this.CmdMoveStop().Error;
//                            if (string.IsNullOrEmpty(stopMsg))
//                            {
//                                break;
//                            }

//                            Thread.Sleep(100);
//                        }

//                        //记录小车停下来时的位置
//                        double stopPosition = car.Position;
//                        while (true)
//                        {
//                            Thread.Sleep(500);
//                            double stopOffset = Math.Abs(car.Position - stopPosition);
//                            if (stopOffset < 0.01 && this.Status == CarStatus.Stopped)
//                            {
//                                car.EmStopPosition = stopPosition;
//                                break;
//                            }
//                            stopPosition = car.Position;
//                        }

//                        //急停之后 没有动了,但是位置变了,需要跳出循环
//                        if (Math.Abs(car.Position - fromPosition) > 10)
//                        {
//                            break;
//                        }

//                        //手动进来的  不用接着走到位置 直接退出去
//                        if (isMasual)
//                        {
//                            return;
//                        }

//                        //var stopMsg = Retry.Try(() => this.Request(FTSCommand.停止运动),200).Error;
//                        //if (!string.IsNullOrEmpty(stopMsg))
//                        //{
//                        //    MessageAggregator<ErrorMsg>.Publish($"小车 {this.Name} 移动至 {endStation.Position} 时遇到急停,且停止移动失败");
//                        //    return;
//                        //}

//                        //急停之后位置没变的,直接移动回去
//                        //标记当前状态为运动中止(解除急停不会立马移动)
//                        while (true)
//                        {
//                            ProductLine.Instance.Sleep(100);
//                            if (ProductLine.Instance.IsEmergencyStop)
//                            {
//                                continue;
//                            }

//                            if (ProductLine.Instance.IsPuase)
//                            {
//                                continue;
//                            }

//                            if (ProductLine.Instance.IsMasual)
//                            {
//                                continue;
//                            }


//                            break;
//                        }

//                        //这里需要判断位置能不能走(重新判断 因为有中断)
//                        while (true)
//                        {
//                            bool canMove = CanMoveHelp.GetCanMove(fromStation, moveRelation);
//                            if (canMove)
//                            {
//                                break;
//                            }
//                            Thread.Sleep(100);
//                        }

//                        //急停解除之后重新运动到指定站点
//                        MoveStation(fromStation, moveRelation, movePosition, isMasual);
//                        //MoveStation(fromStation, endStation);
//                        return;
//                    }
//                    ////这里没有计入急停的时间 超时只报警,不计入
//                    //TimeSpan ts = DateTime.Now - startTime;
//                    //if (ts.TotalMilliseconds > overtime)
//                    //{
//                    //    MessageAggregator<ErrorMsg>.Publish($"小车Moving{car.Name}从 站点:{fromStation.Name}  位置:{fromPosition}  移动至站点：{endStation.Name} 位置:{endStation.MovePosition} 已经消耗时间:{ts.TotalMilliseconds}ms  计划时间{theoryTime} 触发超时退出");
//                    //    //这里 爆出急停,等待人工干预 人工复位
//                    //    //fromStation.IsMoveError = true;
//                    //    ////将小车置换

//                    //    //return;
//                    //}

//                    ProductLine.Instance.Sleep(1);
//                }
//                //站点当前信息更新
//                VisualMoveCollector.DealMoveBefore(fromStation, endStation, car);

//                //停止判断
//                DealStop(fromStation, isMasual);

//                //小车移动完成判断
//                while (true)
//                {

//                    //安全信号缺失报警
//                    if (endStation.IsWorkStation && CommonSetVM.Instance.EnableSafeCheck&&CommonSetVM.Instance.移动允许安全信号检查)
//                    {
//                        if (!endStation.IsSafed && endStation.IsUseSafe)
//                        {
                            
//                            this.CmdMoveStop();
//                            ProductLine.Instance.IsEmergencyStopSoft = true;
//                            MessageAggregator<ErrorMsg>.Publish($"小车{car.Name.Trim('\0')}从 站点:{fromStation.Name}  位置:{fromPosition}  移动至站点：{endStation.Name}时  安全信号缺失");
//                            LogHelp.AddLog<FtpCarLog>(new FtpCarLog($"小车{car.Name.Trim('\0')}从 站点:{fromStation.Name}  位置:{fromPosition}  移动至站点：{endStation.Name}时  安全信号缺失") { CarName = this.Name });
//                        }
//                    }

//                    double offset = Math.Abs(this.Position - endStation.MovePosition);
//                    if (this.Status == CarStatus.Stopped && offset > CommonSetVM.Instance.ArriveDistance)
//                    {
//                        this.CmdMoveAbs(endStation.MovePosition, speed);
//                        Thread.Sleep(40);
//                        //此处不再提示板子故障
//                        //LogHelp.AddLog<ErrorLogEntity>($"小车{this.Name}要移动的位置为{movePosition}  当前位置为{this.Position} 停了下来,板子出现故障");
//                        continue;
//                    }

//                    //移动完成
//                    if (this.Status == CarStatus.Stopped && offset <= CommonSetVM.Instance.ArriveDistance)
//                    {
//                        break;
//                    }

//                    //遭遇急停 在急停解除后重新移动到指定位置
//                    if (ProductLine.Instance.IsEmergencyStop)
//                    {
//                        LogHelp.AddLog<ErrorLogEntity>($"小车{car.Name}从 站点:{fromStation.Name}  位置:{fromPosition}  移动至站点：{endStation.Name} 位置:{endStation.MovePosition} 被急停打断  Stopped");

//                        //让小车停下来,
//                        while (true)
//                        {
//                            var stopMsg = this.CmdMoveStop().Error;
//                            if (string.IsNullOrEmpty(stopMsg))
//                            {
//                                break;
//                            }

//                            Thread.Sleep(100);
//                        }

//                        //记录小车停下来时的位置
//                        double stopPosition = car.Position;
//                        while (true)
//                        {
//                            Thread.Sleep(500);
//                            double stopOffset = Math.Abs(car.Position - stopPosition);
//                            if (stopOffset < 0.01 && this.Status == CarStatus.Stopped)
//                            {
//                                car.EmStopPosition = stopPosition;
//                                break;
//                            }
//                            stopPosition = car.Position;
//                        }

//                        ProductLine.Instance.Sleep(300);
//                        //出现问题 将当前位置记录为临时站点  要去的站点位置清空
//                        double currentInc = endStation.MovePosition - car.Position;
//                        Station tempStation = new Station() { IsTempStation = true, Name = "临时站点" };
//                        tempStation.BoatStation = fromStation.BoatStation;//临时站点需要
//                        tempStation.CurrentCar = car;
//                        fromStation.PassVM.AddTempStation(tempStation);//记录临时点
//                        tempStation.Position = endStation.Position - currentInc;//考虑到收尾相连的情况
//                        endStation.LoadingCar = null; //终点位空
//                        fromStation.LeavingCar = null;//要去的站点记录为空

//                        //标记当前状态为运动中止
//                        AutoRunHelp.WaitAutoRun();


//                        //急停解除之后重新运动到指定站点(这里需要给定条件判断能否移动)
//                        while (true)
//                        {
//                            //能否移动
//                            bool canMove = endStation.PassVM.GetCanMove(tempStation, endStation, currentInc);
//                            if (!canMove)
//                            {
//                                ProductLine.Instance.Sleep(100);
//                                continue;
//                            }
//                            break;
//                        }
//                        MoveStation(tempStation, moveRelation, movePosition, isMasual);
//                        return;
//                    }

//                    //
//                    if (this.触发超时退出)
//                    {
//                        //这里方便调试使用
//                        Thread.Sleep(Convert.ToInt32(overtime) + 1);
//                    }

//                    TimeSpan ts = DateTime.Now - moveTime;
//                    //超时退出
//                    if ((ts.TotalMilliseconds > overtime) && CommonSetVM.Instance.是否检测超时退出)
//                    {
//                        MessageAggregator<ErrorMsg>.Publish($"小车{car.Name}从 站点:{fromStation.Name}  位置:{fromPosition}  移动至站点：{endStation.Name} 位置:{endStation.MovePosition} 已经消耗时间:{ts.TotalMilliseconds}ms  计划时间{theoryTime} Start:{startTime.ToString("yyyyMMdd HH: mm:ss: fff")} Move:{moveTime.ToString("yyyyMMdd HH: mm:ss: fff")} Now:{"yyyyMMdd HH: mm:ss: fff"} 触发超时退出 Stopped");
//                        //fromStation.IsMoveError = true;
//                        ProductLine.Instance.IsEmergencyStopSoft = true;
//                        AutoRunHelp.WaitAutoRun();
//                        //急停解除之后重新运动到指定站点()
//                        //出现问题 将当前位置记录为临时站点  要去的站点位置清空
//                        double currentInc = endStation.MovePosition - car.Position;
//                        Station tempStation = new Station() { IsTempStation = true };
//                        tempStation.BoatStation = fromStation.BoatStation;//临时站点需要
//                        tempStation.CurrentCar = car;
//                        fromStation.PassVM.AddTempStation(tempStation);//记录临时点
//                        tempStation.Position = endStation.Position - currentInc;//考虑到收尾相连的情况
//                        endStation.LoadingCar = null; //终点位空
//                        fromStation.LeavingCar = null;//要去的站点记录为空
//                        while (true)
//                        {
//                            //能否移动
//                            bool canMove = endStation.PassVM.GetCanMove(tempStation, endStation, currentInc);
//                            if (!canMove)
//                            {
//                                ProductLine.Instance.Sleep(100);
//                                continue;
//                            }
//                            break;
//                        }
//                        MoveStation(tempStation, moveRelation, movePosition, isMasual);
//                        return;
//                    }
//                    int sleepTime = GetSleepTime(car.Position, endStation.MovePosition);
//                    ProductLine.Instance.Sleep(sleepTime);
//                }

//                //更新起点离开中的小车 终点当前小车,终点要来的小车
//                VisualMoveCollector.DealMoveAfter(fromStation, endStation, car, movePosition);
//            });
//        }


//        #endregion



//        /// <summary>
//        /// 解除急停与站点偏离
//        /// </summary>
//        /// <param name="car"></param>
//        /// <param name="stopPosition"></param>
//        void 解除急停与站点偏离报警(Car car, double stopPosition)
//        {
//            //判断解除急停
//            while (true)
//            {
//                if (!ProductLine.Instance.IsEmergencyStop)
//                {
//                    break;
//                }
//                Thread.Sleep(100);
//            }

//            //判断站点偏离报警
//            while (true)
//            {
//                double offset = car.Position - stopPosition;
//                offset = Math.Abs(offset);
//                //站点偏离报警
//                if (offset >= CommonSetVM.Instance.ReportPoliceOffset)
//                {
//                    MessageAggregator<ErrorMsg>.Publish($"检测到  小车{car.Name.Trim('\0')}  偏离急停时的位置 {stopPosition}  请手动将其归位");
//                    Thread.Sleep(100);
//                }


//            }




//        }

//        void DealStop(Station station, bool isMasual = false)
//        {
//            while (true)
//            {
//                if (ProductLine.Instance.IsEmergencyStop)
//                {
//                    station.StationState = StationState.系统停止;
//                    ProductLine.Instance.Sleep(200);
//                    continue;
//                }

//                //手动模式停止也能操作
//                if (!isMasual)
//                {
//                    if (ProductLine.Instance.IsPuase)
//                    {
//                        station.StationState = StationState.系统停止;
//                        ProductLine.Instance.Sleep(200);
//                        continue;
//                    }

//                    //手动模式
//                    if (ProductLine.Instance.IsMasual)
//                    {
//                        station.StationState = StationState.系统停止;
//                        ProductLine.Instance.Sleep(200);
//                        continue;
//                    }
//                }



//                break;
//            }
//        }

//        public static int GetSleepTime(double currentPosition, double moveToPosition)
//        {
//            double offset = Math.Abs(currentPosition - moveToPosition);
//            if (offset > 200)
//            {
//                return 100;
//            }
//            else if (offset > 100)
//            {
//                return 10;
//            }
//            else
//            {
//                return 5;
//            }
//        }
//    }

//    /// <summary>
//    /// 运行状态
//    /// </summary>
//    public enum RunState
//    {
//        /// <summary>
//        /// 空
//        /// </summary>
//        None,
//        临时移除,
//        等待小车进入站点,
//        小车进入站点,
//        等待离开前延时,
//        离开前延时完成,
//        系统停止,
//    }



//    public class FTS_SlaveConfig : INotifyPropertyChanged
//    {
//        #region SoftAddress
//        private byte softAddress;

//        public byte SoftAddress
//        {
//            get { return softAddress; }
//            set
//            {
//                if (value == softAddress) return;
//                softAddress = value;
//                OnPropertyChanged(SoftAddressProperty);
//            }
//        }
//        public static PropertyChangedEventArgs SoftAddressProperty = new PropertyChangedEventArgs(nameof(SoftAddress));
//        #endregion

//        #region RfChannel
//        private byte rfChannel;

//        public byte RfChannel
//        {
//            get { return rfChannel; }
//            set
//            {
//                if (value == rfChannel) return;
//                rfChannel = value;
//                OnPropertyChanged(RfChannelProperty);
//            }
//        }
//        public static PropertyChangedEventArgs RfChannelProperty = new PropertyChangedEventArgs(nameof(RfChannel));
//        #endregion

//        #region Ext0
//        private byte ext0;

//        public byte Ext0
//        {
//            get { return ext0; }
//            set
//            {
//                if (value == ext0) return;
//                ext0 = value;
//                OnPropertyChanged(Ext0Property);
//            }
//        }
//        public static PropertyChangedEventArgs Ext0Property = new PropertyChangedEventArgs(nameof(Ext0));
//        #endregion

//        #region Ext1
//        private byte ext1;

//        public byte Ext1
//        {
//            get { return ext1; }
//            set
//            {
//                if (value == ext1) return;
//                ext1 = value;
//                OnPropertyChanged(Ext1Property);
//            }
//        }
//        public static PropertyChangedEventArgs Ext1Property = new PropertyChangedEventArgs(nameof(Ext1));
//        #endregion

//        #region Name
//        private string name;

//        public string Name
//        {
//            get { return name; }
//            set
//            {
//                if (value == name) return;
//                name = value;
//                OnPropertyChanged(NameProperty);
//            }
//        }
//        public static PropertyChangedEventArgs NameProperty = new PropertyChangedEventArgs(nameof(Name));
//        #endregion

//        public event PropertyChangedEventHandler PropertyChanged;
//        public void OnPropertyChanged(PropertyChangedEventArgs e)
//        {
//            PropertyChanged?.Invoke(this, e);
//        }





//        //public void MovaAbs()
//    }
//}
